home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / SQLBIND.PY < prev    next >
Encoding:
Python Source  |  1999-07-28  |  14.3 KB  |  626 lines
  1. """rule bindings for sql grammar."""
  2.  
  3. def elt0(list, context):
  4.     """return first member of reduction"""
  5.     return list[0]
  6.     
  7. def elt1(list, context):
  8.     """return second member"""
  9.     return list[1]
  10.     
  11. def elt2(list, context):
  12.     return list[2]
  13.     
  14. def returnNone(list, context):
  15.     return None
  16.     
  17. def stat1(list, context):
  18.     """return list of len 1 of statements"""
  19.     return list
  20.     
  21. #def statn(list, context):
  22. #    """return a list of statement reductions"""
  23. #    [stat, semi, statlist] = list
  24. #    statlist.insert(0, stat)
  25. #    return statlist
  26.     
  27. def thingcommalist(l, c):
  28.     [thing, comma, list] = l
  29.     list.insert(0, thing)
  30.     return list
  31.     
  32. def listcommathing(l, c):
  33.     [list, comma, thing] = l
  34.     list.append(thing)
  35.     return list
  36.     
  37. statn = thingcommalist
  38. selstat = elt0
  39. insstat = elt0
  40. createtablestat = elt0
  41. droptablestat = elt0
  42. delstat = elt0
  43. updatestat = elt0
  44. createindexstat = elt0
  45. dropindexstat = elt0
  46. createviewstat = elt0
  47. dropviewstat = elt0
  48.  
  49. # drop view statement stuff
  50. def dropview(l, c):
  51.     [drop, view, name] = l
  52.     from sqlsem import DropView
  53.     return DropView(name)
  54.     
  55. # create view statement stuff
  56. def createview(l, c):
  57.     [create, view, name, namelist, as, selection] = l
  58.     from sqlsem import CreateView
  59.     return CreateView(name, namelist, selection)
  60.     
  61. optnamelist0 = returnNone
  62. optnamelistn = elt1
  63.  
  64. # drop index statement stuff
  65. def dropindex(l, c):
  66.     [drop, index, name] = l
  67.     from sqlsem import DropIndex
  68.     return DropIndex(name)
  69.  
  70. # create index statement stuff
  71. def createindex(l, c):
  72.     [create, index, name, on, table, op, namelist, cp] = l
  73.     from sqlsem import CreateIndex
  74.     return CreateIndex(name, table, namelist)
  75.  
  76. def createuniqueindex(l, c):
  77.     [create, unique, index, name, on, table, op, namelist, cp] = l
  78.     from sqlsem import CreateIndex
  79.     return CreateIndex(name, table, namelist, unique=1)
  80.     
  81. names1 = stat1
  82. namesn = listcommathing
  83.  
  84. # update statement stuff
  85.  
  86. def update(l, c):
  87.     [upd, name, set, assns, condition] = l
  88.     from sqlsem import UpdateOp
  89.     return UpdateOp(name, assns, condition)
  90.     
  91. def assn(l, c):
  92.     [col, eq, exp] = l
  93.     return (col, exp)
  94.     
  95. def assn1(l, c):
  96.     [ (col, exp) ] = l
  97.     from sqlsem import TupleCollector
  98.     result = TupleCollector()
  99.     result.addbinding(col, exp)
  100.     return result
  101.     
  102. def assnn(l, c):
  103.     [ result, comma, (col, exp) ] = l
  104.     result.addbinding(col, exp)
  105.     return result
  106.     
  107. # delete statement stuff
  108.  
  109. def deletefrom(l, c):
  110.     [delete, fromkw, name, where] = l
  111.     from sqlsem import DeleteOp
  112.     return DeleteOp(name, where)
  113.     
  114. # drop table stuff
  115.  
  116. def droptable(l, c):
  117.     [drop, table, name] = l
  118.     from sqlsem import DropTable
  119.     return DropTable(name)
  120.  
  121. # create table statement stuff
  122.  
  123. def createtable(list, context):
  124.     [create, table, name, p1, colelts, p2] = list
  125.     from sqlsem import CreateTable
  126.     return CreateTable(name, colelts)
  127.     
  128. colelts1 = stat1
  129. coleltsn = listcommathing
  130. #def coleltsn(list, c):
  131. #    [c1, cc, ce] = list
  132. #    c1.append(ce)
  133. #    return c1
  134.     
  135. coleltid = elt0
  136. coleltconstraint = elt0
  137.  
  138. def coldef(l, c):
  139.     [colid, datatype, default, constraints] = l
  140.     from sqlsem import ColumnDef
  141.     return ColumnDef(colid, datatype, default, constraints)
  142.     
  143. optdef0 = returnNone
  144. optcolconstr0 = returnNone
  145. stringtype = exnumtype = appnumtype = integer = float = varchar = elt0
  146. varcharn = elt0
  147.  
  148. # insert statement stuff
  149.  
  150. def insert1(l, c):
  151.     [insert, into, name, optcolids, insert_spec] = l
  152.     from sqlsem import InsertOp
  153.     return InsertOp(name, optcolids, insert_spec)
  154.     
  155. optcolids0 = returnNone
  156. optcolids1 = elt1
  157. colids1 = stat1
  158. colidsn = listcommathing
  159.  
  160. def insert_values(l, c):
  161.     from sqlsem import InsertValues
  162.     return InsertValues(l[2])
  163.     
  164. def insert_query(l, c):
  165.     from sqlsem import InsertSubSelect
  166.     return InsertSubSelect(l[0])
  167.     
  168. litlist1 = stat1
  169. litlistn = listcommathing
  170.  
  171. sliteral0 = elt0
  172. def sliteralp(l, c):
  173.     [p, v] = l
  174.     return +v
  175.     
  176. def sliterald(l, c):
  177.     [l1, m, l2] = l
  178.     return l1 - l2
  179.     
  180. def sliterals(l, c):
  181.     [l1, p, l2] = l
  182.     return l1 + l2
  183.     
  184. def sliteralm(l, c):
  185.     [m, v] = l
  186.     return -v
  187.  
  188. # select statement stuff
  189.     
  190. def selectx(list, context):
  191.     [sub, optorder_by] = list
  192.     #sub.union_select = optunion
  193.     sub.order_by = optorder_by
  194.     # number of dynamic parameters in this parse.
  195.     sub.ndynamic = context.ndynamic()
  196.     return sub
  197.     
  198. psubselect = elt1
  199.     
  200. def subselect(list, context):
  201.     [select, alldistinct, selectlist, fromkw, trlist,
  202.      optwhere, optgroup, opthaving, optunion] = list
  203.     from sqlsem import Selector
  204.     sel = Selector(
  205.       alldistinct, 
  206.       selectlist, 
  207.       trlist, 
  208.       optwhere, 
  209.       optgroup, 
  210.       opthaving,
  211.       # store # of dynamic parameters seen in this parse.
  212.       ndynamic = context.ndynamic()
  213.       )
  214.     sel.union_select = optunion
  215.     return sel
  216.     
  217. def ad0(list, context):
  218.     return "ALL"
  219.     
  220. adall = ad0
  221.  
  222. def addistinct(list, context):
  223.     return "DISTINCT"
  224.     
  225. def where0(list, context):
  226.     from sqlsem import BTPredicate
  227.     return BTPredicate() # true
  228.     
  229. where1 = elt1
  230.  
  231. group0 = returnNone
  232.  
  233. group1 = elt2
  234.  
  235. colnames1 = stat1
  236.     
  237. colnamesn = listcommathing
  238.  
  239. having0 = returnNone
  240.  
  241. having1 = elt1
  242.  
  243. union0 = returnNone
  244.  
  245. def union1(l, c):
  246.     [union, alldistinct, selection] = l
  247.     from sqlsem import Union
  248.     return Union(alldistinct, selection)
  249.  
  250. def except1(l, c):
  251.     [union, selection] = l
  252.     alldistinct = "DISTINCT"
  253.     from sqlsem import Except
  254.     return Except(alldistinct, selection)
  255.  
  256. def intersect1(l, c):
  257.     [union, selection] = l
  258.     alldistinct = "DISTINCT"
  259.     from sqlsem import Intersect
  260.     return Intersect(alldistinct, selection)
  261.  
  262. order0 = returnNone
  263. order1 = elt2
  264. #orderby = elt2
  265. sortspec1 = stat1
  266. sortspecn = listcommathing
  267.  
  268. def sortint(l, c):
  269.     from sqlsem import PositionedSort
  270.     [num, ord] = l
  271.     from types import IntType
  272.     if type(num)!=IntType or num<=0:
  273.        raise ValueError, `num`+': col position not positive int'
  274.     return PositionedSort(num, ord)
  275.     
  276. def sortcol(l, c):
  277.     from sqlsem import NamedSort
  278.     [name, ord] = l
  279.     return NamedSort(name, ord)
  280.     
  281. def optord0(l, c):
  282.     return "ASC"
  283.     
  284. optordasc = optord0
  285.  
  286. def optorddesc(l, c):
  287.     return "DESC"
  288.  
  289. ## table reference list returns list of (name, name) or (name, alias)
  290. def trl1(l, c):
  291.     [name] = l
  292.     return [(name, name)]
  293.     
  294. def trln(l,c):
  295.     [name, comma, others] = l
  296.     others.insert(0, (name, name))
  297.     return others
  298.     
  299. def trl1a(l,c):
  300.     [name, alias] = l
  301.     return [(name, alias)]
  302.     
  303. def trlna(l,c):
  304.     [name, alias, comma, others] = l
  305.     others.insert(0, (name, alias))
  306.     return others
  307.     
  308. def trl1as(l,c):
  309.     [name, as, alias] = l
  310.     return [(name, alias)]
  311.     
  312. def trlnas(l,c):
  313.     [name, as, alias, comma, others] = l
  314.     others.insert(0, (name, alias))
  315.     return others
  316.     
  317. tablename1 = elt0
  318. columnid1 = elt0
  319.  
  320. def columnname1(list, context):
  321.     [ci] = list
  322.     return columnname2([None, None, ci], context)
  323.     
  324. def columnname2(list, context):
  325.     [table, ignore, col] = list
  326.     from sqlsem import BoundAttribute
  327.     return BoundAttribute(table, col)
  328.     
  329. def dynamic(list, context):
  330.     from sqlsem import BoundAttribute
  331.     # return a new dynamic parameter
  332.     int = context.param()
  333.     return BoundAttribute(0, int)
  334.     
  335. # expression stuff
  336. def literal(list, context):
  337.     [lit] = list
  338.     from sqlsem import Constant
  339.     return Constant(lit)
  340.     
  341. def stringstring(l, c):
  342.     """two strings in sequence = apostrophe"""
  343.     [l1, l2] = l
  344.     from sqlsem import Constant
  345.     value = "%s'%s" % (l1.value0, l2)
  346.     return Constant(value)
  347.     
  348. numlit = literal
  349. stringlit = literal
  350. primarylit = elt0
  351. primary1 = elt0
  352. factor1 = elt0
  353. term1 = elt0
  354. exp1 = elt0
  355.  
  356. def expplus(list, context):
  357.     [exp, plus, term] = list
  358.     return exp + term
  359.     
  360. def expminus(list, context):
  361.     [exp, minus, term] = list
  362.     return exp - term
  363.     
  364. def termtimes(list, context):
  365.     [exp, times, term] = list
  366.     return exp * term
  367.     
  368. def termdiv(list, context):
  369.     [exp, div, term] = list
  370.     return exp / term
  371.     
  372. plusfactor = elt1
  373.  
  374. def minusfactor(list, context):
  375.     [minus, factor] = list
  376.     return -factor
  377.     
  378. primaryexp = elt1
  379.  
  380. primaryset = elt0
  381.  
  382. def countstar(l, c):
  383.     from sqlsem import Count
  384.     return Count("*")
  385.     
  386. def distinctset(l, c):
  387.     [agg, p1, distinct, exp, p2] = l
  388.     return set(agg, exp, 1)
  389.     
  390. distinctcount = distinctset
  391.     
  392. def allset(l, c):
  393.     [agg, p1, exp, p2] = l
  394.     return set(agg, exp, 0)
  395.     
  396. allcount = allset
  397.  
  398. def set(agg, exp, distinct):
  399.     import sqlsem
  400.     if agg=="AVG":
  401.        return sqlsem.Average(exp, distinct)
  402.     if agg=="COUNT":
  403.        return sqlsem.Count(exp, distinct)
  404.     if agg=="MAX":
  405.        return sqlsem.Maximum(exp, distinct)
  406.     if agg=="MIN":
  407.        return sqlsem.Minimum(exp, distinct)
  408.     if agg=="SUM":
  409.        return sqlsem.Sum(exp, distinct)
  410.     if agg=="MEDIAN":
  411.        return sqlsem.Median(exp, distinct)
  412.     raise NameError, `agg`+": unknown aggregate"
  413.     
  414. average = count = maximum = minimum = summation = median = elt0
  415.  
  416. def predicateeq(list, context):
  417.     [e1, eq, e2] = list
  418.     return e1.equate(e2)
  419.     
  420. def predicatene(list, context):
  421.     [e1, lt, gt, e2] = list
  422.     return ~(e1.equate(e2))
  423.     
  424. def predicatelt(list, context):
  425.     [e1, lt, e2] = list
  426.     return e1.lt(e2)
  427.  
  428. def predicategt(list, context):
  429.     [e1, lt, e2] = list
  430.     return e2.lt(e1)
  431.  
  432. def predicatele(list, context):
  433.     [e1, lt, eq, e2] = list
  434.     return e1.le(e2)
  435.  
  436. def predicatege(list, context):
  437.     [e1, lt, eq, e2] = list
  438.     return e2.le(e1)
  439.     
  440. def predbetween(list, context):
  441.     [e1, between, e2, andkw, e3] = list
  442.     from sqlsem import BetweenPredicate
  443.     return BetweenPredicate(e1, e2, e3)
  444.     
  445. def prednotbetween(list, context):
  446.     [e1, notkw, between, e2, andkw, e3] = list
  447.     from sqlsem import BetweenPredicate
  448.     return ~BetweenPredicate(e1, e2, e3)
  449.     
  450. predicate1 = elt0
  451. bps = elt1
  452. bp1 = elt0
  453.  
  454. # exists predicate stuff
  455. predexists = elt0
  456. def exists(l, c):
  457.     [ex, paren1, subquery, paren2] = l
  458.     from sqlsem import ExistsPred
  459.     return ExistsPred(subquery)
  460.  
  461. def notbf(list, context):
  462.     [ notst, thing ] = list
  463.     return ~thing
  464.     
  465. # quantified predicates
  466. nnall = elt0
  467. nnany = elt0
  468.  
  469. def predqeq(list, context):
  470.     [exp, eq, allany, p1, subq, p2] = list
  471.     from sqlsem import QuantEQ, QuantNE
  472.     if allany=="ANY":
  473.        return QuantEQ(exp, subq)
  474.     else:
  475.        return ~QuantNE(exp, subq)
  476.     
  477. def predqne(list, context):
  478.     [exp, lt, gt, allany, p1, subq, p2] = list
  479.     from sqlsem import QuantEQ, QuantNE
  480.     if allany=="ANY":
  481.        return QuantNE(exp, subq)
  482.     else:
  483.        return ~QuantEQ(exp, subq)
  484.     
  485. def predqlt(list, context):
  486.     [exp, lt, allany, p1, subq, p2] = list
  487.     from sqlsem import QuantLT, QuantGE
  488.     if allany=="ANY":
  489.        return QuantLT(exp, subq)
  490.     else:
  491.        return ~QuantGE(exp, subq)
  492.     
  493. def predqgt(list, context):
  494.     [exp, gt, allany, p1, subq, p2] = list
  495.     from sqlsem import QuantGT, QuantLE
  496.     if allany=="ANY":
  497.        return QuantGT(exp, subq)
  498.     else:
  499.        return ~QuantLE(exp, subq)
  500.  
  501. def predqle(list, context):
  502.     [exp, less, eq, allany, p1, subq, p2] = list
  503.     from sqlsem import QuantGT, QuantLE
  504.     if allany=="ANY":
  505.        return QuantLE(exp, subq)
  506.     else:
  507.        return ~QuantGT(exp, subq)
  508.        
  509. def predqge(list, context):
  510.     [exp, gt, eq, allany, p1, subq, p2] = list
  511.     from sqlsem import QuantGE, QuantLT
  512.     if allany=="ANY":
  513.        return QuantGE(exp, subq)
  514.     else:
  515.        return ~QuantLT(exp, subq)
  516.        
  517. # subquery expression
  518. def subqexpr(list, context):
  519.     [p1, subq, p2] = list
  520.     from sqlsem import SubQueryExpression
  521.     return SubQueryExpression(subq)
  522.        
  523. def predin(list, context):
  524.     [exp, inkw, p1, subq, p2] = list
  525.     from sqlsem import InPredicate
  526.     return InPredicate(exp, subq)
  527.     
  528. def prednotin(list, context):
  529.     [exp, notkw, inkw, p1, subq, p2] = list
  530.     from sqlsem import InPredicate
  531.     return ~InPredicate(exp, subq)
  532.     
  533. def predinlits(list, context):
  534.     [exp, inkw, p1, lits, p2] = list
  535.     from sqlsem import InLits
  536.     return InLits(exp, lits)
  537.     
  538. def prednotinlits(list, context):
  539.     [exp, notkw, inkw, p1, lits, p2] = list
  540.     from sqlsem import InLits
  541.     return ~InLits(exp, lits)
  542.  
  543.     
  544. bf1 = elt0
  545.  
  546. def booln(list, context):
  547.     [ e1, andst, e2 ] = list
  548.     return e1&e2
  549.     
  550. bool1 = elt0
  551.  
  552. def searchn(list, context):
  553.     [ e1, orst, e2 ] = list
  554.     return e1 | e2
  555.     
  556. search1 = elt0
  557.  
  558. colalias = elt0
  559.  
  560. # select list stuff
  561. def selectstar(l,c):
  562.     return "*"
  563.     
  564. selectsome = elt0
  565. select1 = elt0
  566.  
  567. # selectsub returns (expression, asname)
  568.  
  569. def select1(list, context):
  570.     [ (exp, name) ] = list
  571.     from sqlsem import TupleCollector
  572.     result = TupleCollector()
  573.     result.addbinding(name, exp)
  574.     return result
  575.     
  576. def selectn(list, context):
  577.     [ selectsubs, comma, select_sublist ] = list
  578.     (exp, name) = select_sublist
  579.     selectsubs.addbinding(name, exp)
  580.     return selectsubs
  581.     
  582. def selectit(list, context):
  583.     [exp] = list
  584.     return (exp, None) # no binding!
  585.     
  586. def selectname(list, context):
  587.     [exp, as, alias] = list
  588.     return (exp, alias)
  589.     
  590. colalias = elt0
  591.  
  592.  
  593. #### do the bindings.
  594.  
  595. # note: all reduction function defs must precede this assign
  596. VARS = vars()
  597.  
  598. class punter:
  599.    def __init__(self, name):
  600.        self.name = name
  601.    def __call__(self, list, context):
  602.        print "punt:", self.name, list
  603.        return list
  604.        
  605. class tracer:
  606.    def __init__(self, name, fn):
  607.        self.name = name
  608.        self.fn = fn
  609.        
  610.    def __call__(self, list, context):
  611.        print self.name, list
  612.        return self.fn(list, context)
  613.  
  614. def BindRules(sqlg):
  615.     for name in sqlg.RuleNameToIndex.keys():
  616.         if VARS.has_key(name):
  617.            #print "binding", name
  618.            sqlg.Bind(name, VARS[name]) # nondebug
  619.            #sqlg.Bind(name, tracer(name, VARS[name]) ) # debug
  620.         else:
  621.            print "unbound", name
  622.            sqlg.Bind(name, punter(name))
  623.     return sqlg
  624.  
  625.  
  626.